new Vue({
    el: '#app',
    data: {
        searchText: '',
        isSearchActive: false,
        isSearching: false,
        isLoading: false,
        currentLoadingText: '正在初始化...', // 新增：当前加载提示文本
        loadingTexts: [ // 新增：加载提示文本数组
            '正在分析您的搜索习惯...',
            '连接智能美食数据库...',
            '检测附近匹配的餐厅...',
            '加载个性化推荐算法...',
            '扫描用户历史偏好...',
            '匹配口味相似度...',
            '查询实时菜单信息...',
            '优化地理位置搜索...',
            '寻找隐藏的美食宝藏...',
            '分析热门菜品趋势...',
            '加载用户评价数据...',
            '构建美食知识图谱...',
            '筛选符合条件的食谱...',
            '检查餐厅营业状态...',
            '计算最佳路线...',
            '同步好友推荐...',
            '加载高清美食图片...',
            '准备智能推荐列表...',
            '生成搜索结果摘要...',
            '马上就好，请稍候...',
            '正在为您精心挑选...',
            'AI正在努力思考中...'
        ],
        loadingInterval: null, // 新增：用于存储定时器
        showContent: false,
        showHotPot: false,
        description: '',
        isThinking: false, // 新增：标识AI是否正在思考
        thinkingStage: '', // 新增：当前思考阶段 ('analyzing' | 'recommending' | 'completed')
        currentTip: '你可以问我关于美食的任何问题，例如"推荐北京的特色小吃"或"最适合夏天吃的菜"',
        aiTips: [
            '你可以问我关于美食的任何问题，例如"推荐北京的特色小吃"或"最适合夏天吃的菜"',
            '想了解某道菜的做法？直接搜索菜名+"做法"即可',
            '搜索"附近的餐厅"可以获取周边美食推荐',
            '输入食材名称，我可以推荐相关的美食做法',
            '对某种口味感兴趣？搜索"麻辣"、"酸甜"等关键词试试',
            '想找适合聚会的美食？搜索"聚餐"或"多人"',
            '寻找健康饮食建议？搜索"低脂"、"低糖"或"健康食谱"'
        ],
        hotKeywords: ['烤鸭', '火锅', '小龙虾', '烧烤', '川菜', '粤菜', '北京烤鸭', '麻辣香锅'],
        recommendations: [],
        userInfo: null, // 新增：存储用户信息
        searchResults: [],
        visibleRecommendations: [],
        visibleSearchResults: [],
                // 新增：滚动节流相关变量
                scrollThrottleTimer: null,    // 滚动节流定时器
                lastScrollTime: 0,            // 上次滚动时间戳
                scrollInterval: 1000,         // 滚动间隔（毫秒）
                isScrollAnimating: false      // 是否正在执行滚动动画
    },
    mounted() {
        // 创建背景动画
        //this.createBackgroundAnimation();
        // 加载数据
        this.loadData();
        // 远程获取热词和提示
        this.loadRemoteConfig();
        // 定时切换AI提示
        this.startTipRotation();
    },
    methods: {
        // 加载数据
        loadData() {
            let data = null; // 初始化为 null
            try {
                // 尝试从 Android 获取 JSON 字符串
                const userInfoString = Android.ObtainUserInfo();
                //console.warn(userInfoString);
                console.log('Android.ObtainUserInfo() raw:', userInfoString);
                if (userInfoString) {
                            const parsedData = JSON.parse(userInfoString); // 解析 JSON 字符串
                            // 从 nameValuePairs 中提取数据
                            data = parsedData.nameValuePairs || {
                                latitude: parsedData.latitude || "39.9042",
                                longitude: parsedData.longitude || "116.4074",
                                userId: parsedData.userId || "1"
                            };
                    console.warn('Parsed UserInfo:', data);
                } else {
                     console.warn("Android.ObtainUserInfo() 返回空或无效数据");
                     // 如果 Android 返回空，使用模拟数据
                     data = { "latitude": "39.9042", "longitude": "116.4074", "userId": "testUser001"}; // 北京坐标示例
                     console.warn('使用模拟用户信息:', data);
                }
            } catch (e) {
                console.error("处理 Android.ObtainUserInfo() 出错:", e);
                // 获取失败或解析失败时使用模拟数据
                data = { "latitude": "39.9042", "longitude": "116.4074", "userId": "7"}; // 北京坐标示例
                console.log('获取用户信息失败，使用模拟用户信息:', data);
            }
            this.userInfo = data; // 存储用户信息
        },
        
        // 远程加载配置信息（热词和AI提示）
        async loadRemoteConfig() {
            console.log('开始远程获取配置信息...');
            
            // 并行获取热词和AI提示
            const promises = [
                this.fetchHotKeywords(),
                this.fetchAiTips()
            ];
            
            try {
                await Promise.all(promises);
                console.log('远程配置加载完成');
            } catch (error) {
                console.error('远程配置加载过程中出现错误:', error);
            }
        },
        
        // 获取热搜词
        async fetchHotKeywords() {
            try {
                console.log('正在获取远程热搜词...');
                const data = await this.fetchBackendData('/config/hot-keywords/', {
                    userId: this.userInfo?.userId,
                    location: {
                        latitude: this.userInfo?.latitude,
                        longitude: this.userInfo?.longitude
                    }
                });
                
                if (data && Array.isArray(data.keywords) && data.keywords.length > 0) {
                    this.hotKeywords = data.keywords;
                    console.log('成功获取远程热搜词:', this.hotKeywords);
                } else {
                    console.log('远程热搜词数据为空或格式不正确，使用默认值');
                }
            } catch (error) {
                console.error('获取远程热搜词失败，使用默认值:', error);
                // 保持默认值，不需要额外操作
            }
        },
        
        // 获取AI提示
        async fetchAiTips() {
            try {
                console.log('正在获取远程AI提示...');
                const data = await this.fetchBackendData('/config/ai-tips/', {
                    userId: this.userInfo?.userId,
                    version: '1.0'
                });
                
                if (data && Array.isArray(data.tips) && data.tips.length > 0) {
                    this.aiTips = data.tips;
                    // 更新当前显示的提示为第一个新提示
                    this.currentTip = this.aiTips[0];
                    console.log('成功获取远程AI提示:', this.aiTips);
                } else {
                    console.log('远程AI提示数据为空或格式不正确，使用默认值');
                }
            } catch (error) {
                console.error('获取远程AI提示失败，使用默认值:', error);
                // 保持默认值，不需要额外操作
            }
        },
        
        // 创建背景动画
        createBackgroundAnimation() {
            const container = document.querySelector('.background-animation');
            const ballCount = 4;
            
            for (let i = 0; i < ballCount; i++) {
                const ball = document.createElement('div');
                ball.classList.add('floating-ball');
                
                // 随机大小
                const size = Math.random() * 100 + 550;
                ball.style.width = `${size}px`;
                ball.style.height = `${size}px`;
                
                // 随机位置
                const posX = Math.random() * 100;
                const posY = Math.random() * 100;
                ball.style.left = `${posX}%`;
                ball.style.top = `${posY}%`;
                
                // 随机颜色
                const hue = Math.random() * 360;
                ball.style.background = `hsla(${hue}, 40%, 20%, 0.2)`;
                
                // 随机动画
                const duration = Math.random() * 20 + 15; // 增加基础时长，减慢速度
                const delay = Math.random() * 10; // 增加延迟随机性
                
                // 应用预定义的 'float' 动画，使用 'infinite' 代替 'infinite alternate' 实现循环
                ball.style.animation = `float ${duration}s ease-in-out ${delay}s infinite`; 
                
                // 可选：添加微小的初始随机偏移，避免起始过于一致
                // ball.style.transform = `translate(${Math.random() * 10 - 5}px, ${Math.random() * 10 - 5}px)`; 

                container.appendChild(ball);
            }
            
            // 移除动态添加 @keyframes 的代码
            // const style = document.createElement('style');
            // style.textContent = `...`;
            // document.head.appendChild(style);
        },

    // 文本截断函数，限制文本长度
    truncateText(text, maxLength = 20) {
        if (!text) return '';
        if (text.length <= maxLength) {
            return text;
        }
        return text.substring(0, maxLength) + '...';
    },
    
   // 图片加载错误处理
   imageError(event) {
    // 防止无限循环：检查当前src是否已经是默认图片
    if (event.target.src.indexOf('imgdef.webp') !== -1) {
        // 已经是默认图片了，不再替换
        console.warn('默认图片也加载失败:', event.target.src);
        // 移除error事件监听，防止再次触发
        event.target.removeEventListener('error', this.imageError);
        return;
    }
    
    // 处理图片加载失败，替换为默认图片
    event.target.src = 'file:///android_asset/img/imgdef.webp';
},

        // 开始AI提示轮换
        startTipRotation() {
            setInterval(() => {
                const randomIndex = Math.floor(Math.random() * this.aiTips.length);
                this.currentTip = this.aiTips[randomIndex];
            }, 5000); // 每5秒切换一次提示
        },
        
        // 使用热搜词
        useKeyword(keyword) {
            this.searchText = keyword;
            this.activateSearch();
            this.search();
        },
        
        // 激活搜索
        activateSearch() {
            this.isSearchActive = true;
            this.isSearching = true;
        },
        
// 新增：用于调用后端 API 的辅助函数
        // 支持的API端点：
        // - /config/hot-keywords/ : 获取热搜词
        // - /config/ai-tips/ : 获取AI提示
        // - /comments/nearby/ : 获取附近评论
        // - /activities/nearby/ : 获取附近活动
        // - /users/content/ : 获取用户内容
        // - /friends/list/ : 获取好友列表
async fetchBackendData(endpoint, body) {
    try {
        // 注意：你需要根据实际情况确定后端的 URL
        // 例如：const backendBaseUrl = 'http://localhost:8000';
        const backendBaseUrl = 'http://124.71.77.44:1120'; // 请替换为你的后端服务地址
        const response = await fetch(`${backendBaseUrl}${endpoint}`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Accept': 'application/json',
            },
            body: JSON.stringify(body)
        });
        if (!response.ok) {
            console.error(`Backend API error! Endpoint: ${endpoint}, Status: ${response.status}`);
            // 尝试读取错误信息
            let errorData;
            try {
                errorData = await response.json();
            } catch (e) {
                errorData = { message: await response.text() };
            }
            throw new Error(`Backend API request failed for ${endpoint}: ${errorData.message || response.statusText}`);
        }
        const data = await response.json();
        if (data.status !== 'success') {
             console.error(`Backend API returned error for ${endpoint}:`, data.message);
             throw new Error(`Backend API error for ${endpoint}: ${data.message}`);
        }
        return data.data || data; // 返回 data 字段或整个响应（根据你的 API 设计）
    } catch (error) {
        console.error(`Failed to fetch backend data from ${endpoint}:`, error);
        return null; // 返回 null 表示失败
    }
},

        // 新增：解析 AI 返回的 JSON 响应
        parseAIJsonResponse(aiContent) {
            if (!aiContent) {
                console.error('AI 响应内容为空');
                return null;
            }
            console.log('原始 AI 响应内容:', aiContent);
            let jsonString = aiContent.trim();

            // 尝试去除常见的 markdown 代码块标记
            if (jsonString.startsWith('```json')) {
                jsonString = jsonString.substring(7); // 去除 ```json
            } else if (jsonString.startsWith('```')) {
                 jsonString = jsonString.substring(3); // 去除 ```
            }
            if (jsonString.endsWith('```')) {
                jsonString = jsonString.substring(0, jsonString.length - 3); // 去除末尾的 ```
            }
            jsonString = jsonString.trim(); // 再次 trim

            // 如果去除标记后不是以 { 开头，尝试查找第一个 { 和最后一个 }
            if (!jsonString.startsWith('{') || !jsonString.endsWith('}')) {
                const startIndex = jsonString.indexOf('{');
                const endIndex = jsonString.lastIndexOf('}');
                if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
                    jsonString = jsonString.substring(startIndex, endIndex + 1);
                    console.log('提取 {} 之间的内容:', jsonString);
                } else {
                    console.warn('在 AI 响应中未能找到有效的 JSON 对象结构。');
                    // 即使找不到，也尝试解析，让 JSON.parse 报错以便调试
                }
            }

            try {
                const result = JSON.parse(jsonString);
                console.log('成功解析 AI JSON:', result);
                return result;
            } catch (parseError) {
                console.error('解析 AI 返回的 JSON 失败:', parseError);
                console.error('尝试解析的无效 JSON 字符串:', jsonString);
                console.error('原始 AI 响应:', aiContent); // 打印原始响应帮助调试
                return null; // 返回 null 表示解析失败
            }
        },

// 修改后的 callAI 函数
async callAI(prompt) {
    // 确保思考状态正确设置
            this.isThinking = false; // 第一次不显示思考状态
    this.thinkingStage = 'analyzing';
            this.description = '正在分析您的搜索意图...'; // 显示分析提示
    
    // --- 第一次 AI 调用：分析用户意图 ---
    const firstSystemPrompt = `
    你是一个全能个人助理，你可以分析用户提出的问题，返回json格式数据，你需要返回的内容如下。

    - Category：类别（吃，喝，玩，乐，购）中选择。例如["吃", "喝"]
    - Type: 类型（活动，评论，好友）如果要查找好友则可以输出["好友"]，如果想要加入活动可以输出["活动"]。例如["评论", "活动"], 如果想要查询更多则可以输出["评论"]。评论中什么都能找到。
    - Target： 查询目标（自己/全局）如果用户要查询自己的历史记录则可输出["自己"]。例如["自己"]

    **重要：确保返回的 JSON 格式严格有效，可以直接被 JavaScript 的 JSON.parse() 解析。不要在 JSON 之外添加任何其他文本或解释。**
    问题示例1：我好饿啊，天气又好热不想出门。
    示例输出格式：
    {
      "Category": ["吃", "喝"],
      "Type": ["评论", "活动"],
              "Target": ["全局"],
              "Search_Keywords": ["冷饮", "空调", "夏天美食"]
    }
    问题示例2：你还记不记得，我之前吃过一个火锅特别好吃，貌似是在一家叫"超级啥啥"的店。
    示例输出格式：
    {
      "Category": ["吃", "喝"],
      "Type": ["评论", "活动"],
              "Target": ["自己"],
              "Search_Keywords": ["火锅", "超级"]
    }
    问题示例3：最近很无聊，想找几个朋友嗨皮。你帮我想想办法呗。
    示例输出格式：
    {
      "Category": ["玩", "乐"],
      "Type": ["活动", "好友", "评论"],
              "Target": ["全局"],
              "Search_Keywords": ["朋友", "嗨皮", "聚会"]
    }
    `;

    let firstUserPrompt = `搜索词: ${prompt}`;
    if (this.userInfo) {
        firstUserPrompt += `\n用户信息: ${JSON.stringify(this.userInfo)}`;
    }

    const firstRequestBody = {
                model: "wzd",
        temperature: 0.1,
        top_p: 0.1,
        messages: [
            { role: "system", content: firstSystemPrompt },
            { role: "user", content: firstUserPrompt }
        ],
        stream: true
    };

    let analysisResult;
    try {
        console.log('First AI Call Request:', JSON.stringify(firstRequestBody, null, 2));
        
        // 流式处理第一次AI调用
                const firstResponse = await fetch("https://api.leftnorth.com/v1/chat/completions", {
            method: 'POST',
            headers: {
                'Accept': 'text/event-stream',
                'Content-Type': 'application/json',
                'Authorization': `Bearer sk-dff7bc8e-084d-45a9-a837-c634e64ca71b`,
            },
            body: JSON.stringify(firstRequestBody)
        });

        if (!firstResponse.ok) {
            throw new Error(`First AI call HTTP error! status: ${firstResponse.status}`);
        }

                // 处理流式响应 - 第一次不显示思考内容
        const reader = firstResponse.body.getReader();
        const decoder = new TextDecoder();
        let buffer = '';
        let firstAllContent = '';
        let firstThinkingContent = '';
        let firstJsonContent = '';
        let isInThinking = false;
        let hasFoundJson = false;

        while (true) {
            const { done, value } = await reader.read();
            if (done) break;

            buffer += decoder.decode(value, { stream: true });
            const lines = buffer.split('\n');
            buffer = lines.pop() || '';

            for (const line of lines) {
                if (line.startsWith('data: ')) {
                    const data = line.slice(6).trim();
                    if (data === '[DONE]') continue;
                    if (data === '') continue;
                    
                    try {
                        const parsed = JSON.parse(data);
                        if (parsed.choices && parsed.choices[0] && parsed.choices[0].delta && parsed.choices[0].delta.content) {
                            const content = parsed.choices[0].delta.content;
                            firstAllContent += content;
                            
                                    // 第一次AI调用时不显示思考内容，只收集数据
                            if (content.includes('<think>')) {
                                isInThinking = true;
                                const thinkStart = content.indexOf('<think>') + 7;
                                const beforeThink = content.substring(0, content.indexOf('<think>'));
                                const afterThink = content.substring(thinkStart);
                                
                                if (beforeThink && !hasFoundJson) {
                                    firstJsonContent += beforeThink;
                                }
                                firstThinkingContent += afterThink;
                                
                                        // 第一次不更新显示，只记录日志
                                        console.log('第一次AI思考内容收集中:', firstThinkingContent);
                            } else if (isInThinking && content.includes('</think>')) {
                                const thinkEnd = content.indexOf('</think>');
                                const beforeEnd = content.substring(0, thinkEnd);
                                const afterEnd = content.substring(thinkEnd + 8);
                                
                                firstThinkingContent += beforeEnd;
                                        console.log('第一次AI思考内容收集完成:', firstThinkingContent.trim());
                                
                                isInThinking = false;
                                hasFoundJson = true;
                                firstJsonContent += afterEnd.replace(/^\s+/, '');
                            } else if (isInThinking) {
                                firstThinkingContent += content;
                                        console.log('第一次AI思考内容增量收集:', content);
                            } else if (hasFoundJson || !isInThinking) {
                                firstJsonContent += content;
                            }
                        }
                    } catch (e) {
                        console.warn('解析流数据失败:', e, 'data:', data);
                    }
                }
            }
        }

        console.log('First AI 完整内容:', firstAllContent);
        console.log('First AI 思考内容:', firstThinkingContent);
        console.log('First AI JSON内容:', firstJsonContent);

        // 解析第一次AI的JSON结果
        let jsonToParse = firstJsonContent || firstAllContent;
        if (jsonToParse) {
            analysisResult = this.parseAIJsonResponse(jsonToParse);
            if (!analysisResult) {
                throw new Error('解析第一次 AI 响应失败');
            }

                    // 验证基本结构（兼容新增的Search_Keywords字段）
            if (!analysisResult || !Array.isArray(analysisResult.Category) || !Array.isArray(analysisResult.Type) || !Array.isArray(analysisResult.Target)) {
                console.error('First AI 返回的 JSON 结构不符合预期:', analysisResult);
                throw new Error('First AI 返回的 JSON 结构不符合预期');
            }
                    
                    // 可选字段：Search_Keywords 
                    if (analysisResult.Search_Keywords && !Array.isArray(analysisResult.Search_Keywords)) {
                        console.warn('Search_Keywords 字段存在但格式不正确，将忽略该字段');
                        analysisResult.Search_Keywords = [];
                    }
            
            console.log('First AI Analysis Result:', analysisResult);
                    console.log('搜索关键词:', analysisResult.Search_Keywords || []);

        } else {
            throw new Error('First AI 响应格式不正确');
        }
    } catch (error) {
        console.error('第一次调用 AI 失败:', error);
        return {
            description: `抱歉，分析您的请求时遇到问题：${error.message}`,
            recommendations: [],
            searchResults: []
        };
    }

    // --- 数据查询 ---
            // 更新描述为数据查询阶段
            this.description = '正在查询相关数据...';
            
    let fetchedData = {
        nearbyComments: null,
        nearbyActivities: null,
        userContent: null,
        friendList: null
    };
    const promises = [];
            const { Category, Type, Target, Search_Keywords } = analysisResult;
    const userId = this.userInfo?.userId;
    const latitude = this.userInfo?.latitude;
    const longitude = this.userInfo?.longitude;

            // 构建搜索参数，包含AI分析出的关键词
            const searchParams = {
                Category: Category,
                Search_Keywords: Search_Keywords || [], // 传递搜索关键词给后端
                limit: 10,
                page: 1
            };

    if (Target.includes("全局")) {
        if (Type.includes("评论") && latitude && longitude) {
            promises.push(
                        this.fetchBackendData("/comments/nearby/", { 
                            latitude: latitude, 
                            longitude: longitude, 
                            ...searchParams
                        })
                    .then(data => { 
                        if(data && Array.isArray(data)) {
                            let processedComments = data.map(comment => ({
                                类型: '评论', ID: comment.commentId, 标题: comment.commentTitle, 内容: comment.commentContent, 
                                参与时间: comment.commentPublishTime, 位置: comment.location, 距离: comment.distance, ...comment
                            }));
                            fetchedData.nearbyComments = processedComments;
                                    console.log('Processed Nearby Comments with keywords:', fetchedData.nearbyComments);
                        } else {
                            fetchedData.nearbyComments = []; 
                        }
                    })
                    .catch(err => { console.error("获取附近评论失败:", err); fetchedData.nearbyComments = []; })
            );
        }
        if (Type.includes("活动") && latitude && longitude) {
            promises.push(
                        this.fetchBackendData("/activities/nearby/", { 
                            latitude: latitude, 
                            longitude: longitude, 
                            ...searchParams
                        })
                    .then(data => { 
                        if(data && Array.isArray(data)) {
                                    console.log('获取到的原始活动数据 with keywords:', data);
                            let processedActivities = data.map(activity => ({
                                类型: '活动', ID: activity.activityId, 标题: activity.activityTitle, 内容: activity.activityDetails, 
                                参与时间: activity.activityPublishTime, 位置: activity.location, 距离: activity.distance, ...activity
                            }));
                            fetchedData.nearbyActivities = processedActivities;
                                    console.log('Processed Nearby Activities with keywords:', fetchedData.nearbyActivities);
                        } else {
                            fetchedData.nearbyActivities = []; 
                        }
                    })
                    .catch(err => { console.error("获取附近活动失败:", err); fetchedData.nearbyActivities = []; })
            );
        }
    }

    if (Target.includes("自己") && userId) {
        promises.push(
                    this.fetchBackendData("/users/content/", { 
                        userId: userId,
                        Search_Keywords: Search_Keywords || [] // 在个人内容中也使用关键词搜索
                    })
                .then(data => {
                    if (data && data.status === 'success') {
                        let processedContent = [];
                        if (Array.isArray(data.activities)) {
                            processedContent = processedContent.concat(data.activities.map(activity => ({
                                类型: '活动', ID: activity.activityId, 标题: activity.activityTitle, 内容: activity.activityDetails, 参与时间: activity.activityPublishTime, ...activity
                            })));
                        }
                        if (Array.isArray(data.comments)) {
                             processedContent = processedContent.concat(data.comments.map(comment => ({
                                类型: '评论', ID: comment.commentId, 标题: comment.commentTitle, 内容: comment.commentContent, 参与时间: comment.commentPublishTime, ...comment
                            })));
                        }
                                
                                // 如果有搜索关键词，进行本地过滤提高匹配度
                                // if (Search_Keywords && Search_Keywords.length > 0) {
                                //     processedContent = this.filterContentByKeywords(processedContent, Search_Keywords);
                                //     console.log('使用关键词过滤后的用户内容:', processedContent);
                                // }
                                
                        processedContent.sort((a, b) => new Date(b.参与时间) - new Date(a.参与时间));
                        fetchedData.userContent = processedContent;
                                console.log('Processed User Content with keywords:', fetchedData.userContent);
                    } else {
                         console.warn('获取用户内容失败或数据格式不正确:', data);
                         fetchedData.userContent = [];
                    }
                })
                .catch(error => {
                     console.error('处理用户内容数据时出错:', error);
                     fetchedData.userContent = [];
                })
        );
    }

    if (Type.includes("好友") && userId) {
        promises.push(
            this.fetchBackendData("/friends/list/", { user_id: userId })
                .then(data => { if(data && Array.isArray(data)) fetchedData.friendList = data; else fetchedData.friendList = []; })
                 .catch(err => { console.error("获取好友列表失败:", err); fetchedData.friendList = []; })
        );
    }

    try {
        await Promise.all(promises);
        console.log('Fetched Backend Data:', fetchedData);
    } catch (error) {
        console.error('查询后端数据时出错:', error);
    }

    // --- 整合并标准化所有获取到的数据 ---
    let allItems = [];
    if (fetchedData.nearbyComments) {
        allItems = allItems.concat(fetchedData.nearbyComments.map(item => this.mapItemToFrontendFormat(item, '评论')));
    }
    if (fetchedData.nearbyActivities) {
        allItems = allItems.concat(fetchedData.nearbyActivities.map(item => this.mapItemToFrontendFormat(item, '活动')));
    }
    if (fetchedData.userContent) {
        allItems = allItems.concat(fetchedData.userContent.map(item => this.mapItemToFrontendFormat(item, '自己')));
    }

            // 按关联度和距离重新排序，让活动和评论可以穿插显示
            allItems = this.sortItemsByRelevanceAndDistance(allItems);
            console.log('按关联度和距离排序后的所有项目:', allItems);

            // 如果有搜索关键词，对所有结果进行二次过滤和排序优化
            if (Search_Keywords && Search_Keywords.length > 0) {
                allItems = this.optimizeItemsByKeywords(allItems, Search_Keywords);
                console.log('关键词优化后的所有项目:', allItems);
            }

    console.log('All Formatted Items for AI:', allItems);

    if (allItems.length === 0) {
        console.log("没有获取到任何相关数据，无法进行推荐。");
        return {
            description: "抱歉，未能找到相关内容。",
            recommendations: [],
            searchResults: []
        };
    }

            // --- 立即展示搜索结果，提升用户体验 ---
            // 在第二次AI调用前，先展示所有找到的结果
            this.searchResults = allItems.slice(0, 30).map(item => ({
                ...item,
                Content: item.Content || '',
                Location: item.Location || '',
                Time: item.Time || '',
                tags: item.tags || [],
                rating: item.rating || null,
                author: {
                    name: item.author?.name || '匿名用户',
                    avatar: item.author?.avatar || 'https://via.placeholder.com/20x20'
                }
            }));
            
            // 更新 showHotPot 逻辑
            this.showHotPot = this.searchResults.some(item => 
                item.title && item.title.includes('火锅')
            );
            
            // 停止第一阶段的加载动画
            this.isLoading = false;
            this.stopLoadingAnimation();
            
            // 立即触发搜索结果的显示动画
            this.$nextTick(() => {
                this.animateSearchResults(); // 新增方法，只显示搜索结果的动画
            });

    // --- 第二次 AI 调用：选择推荐项 ---
            // 现在开始显示思考状态
            this.isThinking = true;
            this.isLoading = false;
            this.thinkingStage = 'recommending';
            this.description = '正在为您精心挑选推荐...'; // 初始化第二次的描述
            
    const secondSystemPrompt = `
    你是一个智能助理，负责根据用户原始搜索意图和提供的数据列表，选择最符合的一个项目作为推荐。

    你需要返回严格的 JSON 格式，包含以下字段：
    - 类型: 被选中项目的类型 (例如: "评论", "活动")。
    - ID: 被选中项目的 ID。
    - 选中理由: 简要说明为什么选择这个项目推荐给用户 (string)。

    请基于以下信息进行选择和说明：
    - 用户的原始搜索词。
    - 第一次 AI 分析出的意图 (Category, Type, Target)。
    - 提供的数据项列表 (只包含 类型, ID, 标题)。

    **重要：确保返回的 JSON 格式严格有效，可以直接被 JavaScript 的 JSON.parse() 解析。不要在 JSON 之外添加任何其他文本或解释。**
    `;

    const simplifiedItemsForAI = allItems.map(item => ({
        类型: item.类型,
        ID: item.ID,
        标题: item.title,
        内容: item.Content,
        发布时间: item.Time,
        位置: item.Location,
        距离: item.Distance + '公里，' + (item.Distance < 10 ? '非常近' : item.Distance < 50 ? '不远' : item.Distance < 100 ? '有点远' : '很远')
    }));

    let secondUserPrompt = `
    原始搜索词: ${prompt}
    分析意图: ${JSON.stringify(analysisResult)}
    可选数据列表: ${JSON.stringify(simplifiedItemsForAI)}

    请从以上列表中选择最匹配用户意图的一项，并给出选中理由。注意理由不要提及ID，只从心理角度说明选择即可。
    输出示例：
    {
        "类型": "评论",
        "ID": "comment123",
        "选中理由": "让我想想，根据你的习惯我觉得你应该爱吃辣椒吧？，我猜测你是想要找一个四川口味的火锅，那么我选中的这个就很符合你的要求哦。"
    }
    `;

    const secondRequestBody = {
        model: "mini",
        temperature: 0.1,
        top_p: 0.1,
        messages: [
            { role: "system", content: secondSystemPrompt },
            { role: "user", content: secondUserPrompt }
        ],
        stream: true
    };

    try {
        console.log('Second AI Call Request:', JSON.stringify(secondRequestBody, null, 2));
        
        // 流式处理第二次AI调用
                const secondResponse = await fetch("https://api.leftnorth.com/v1/chat/completions", {
            method: 'POST',
            headers: {
                'Accept': 'text/event-stream',
                'Content-Type': 'application/json',
                'Authorization': `Bearer sk-dff7bc8e-084d-45a9-a837-c634e64ca71b`,
            },
            body: JSON.stringify(secondRequestBody)
        });

        if (!secondResponse.ok) {
            throw new Error(`Second AI call HTTP error! status: ${secondResponse.status}`);
        }

                // 处理第二次AI的流式响应 - 这次显示思考内容
        const reader = secondResponse.body.getReader();
        const decoder = new TextDecoder();
        let buffer = '';
        let secondAllContent = '';
        let secondThinkingContent = '';
        let secondJsonContent = '';
        let isInThinking = false;
        let hasFoundJson = false;

        while (true) {
            const { done, value } = await reader.read();
            if (done) break;

            buffer += decoder.decode(value, { stream: true });
            const lines = buffer.split('\n');
            buffer = lines.pop() || '';

            for (const line of lines) {
                if (line.startsWith('data: ')) {
                    const data = line.slice(6).trim();
                    if (data === '[DONE]') continue;
                    if (data === '') continue;
                    
                    try {
                        const parsed = JSON.parse(data);
                        if (parsed.choices && parsed.choices[0] && parsed.choices[0].delta && parsed.choices[0].delta.content) {
                            const content = parsed.choices[0].delta.content;
                            secondAllContent += content;
                            
                                    // 第二次AI调用时实时显示思考内容
                            if (content.includes('<think>')) {
                                isInThinking = true;
                                const thinkStart = content.indexOf('<think>') + 7;
                                const beforeThink = content.substring(0, content.indexOf('<think>'));
                                const afterThink = content.substring(thinkStart);
                                
                                if (beforeThink && !hasFoundJson) {
                                    secondJsonContent += beforeThink;
                                }
                                secondThinkingContent += afterThink;
                                
                                // 实时更新思考内容(去除前后空白字符)
                                        this.updateThinkingContent(secondThinkingContent.trim());
                            } else if (isInThinking && content.includes('</think>')) {
                                const thinkEnd = content.indexOf('</think>');
                                const beforeEnd = content.substring(0, thinkEnd);
                                const afterEnd = content.substring(thinkEnd + 8);
                                
                                secondThinkingContent += beforeEnd;
                                // 去除思考内容的前后空白字符，包括换行符
                                        this.updateThinkingContent(secondThinkingContent.trim());
                                
                                isInThinking = false;
                                hasFoundJson = true;
                                // 去除afterEnd开头的换行符和空白字符
                                secondJsonContent += afterEnd.replace(/^\s+/, '');
                            } else if (isInThinking) {
                                secondThinkingContent += content;
                                // 实时更新思考内容(去除前后空白字符)
                                        this.updateThinkingContent(secondThinkingContent.trim());
                            } else if (hasFoundJson || !isInThinking) {
                                secondJsonContent += content;
                            }
                        }
                    } catch (e) {
                        console.warn('解析流数据失败:', e, 'data:', data);
                    }
                }
            }
        }

        console.log('Second AI 完整内容:', secondAllContent);
        console.log('Second AI 思考内容:', secondThinkingContent);
        console.log('Second AI JSON内容:', secondJsonContent);

        // 解析第二次AI的JSON结果
        let jsonToParse = secondJsonContent || secondAllContent;
        if (jsonToParse) {
            const aiChoice = this.parseAIJsonResponse(jsonToParse);

            if (!aiChoice) {
                console.error('解析 Second AI 返回的 JSON 失败');
                        // 如果解析失败，也展示搜索结果
                        this.searchResults = allItems.slice(0, 30).map(item => ({
                            ...item,
                            Content: item.Content || '',
                            Location: item.Location || '',
                            Time: item.Time || '',
                            tags: item.tags || [],
                            rating: item.rating || null,
                            author: {
                                name: item.author?.name || '匿名用户',
                                avatar: item.author?.avatar || 'https://via.placeholder.com/20x20'
                            }
                        }));
                        
                return {
                    description: "抱歉，AI 推荐解析失败，为您展示所有找到的结果。",
                    recommendations: [],
                            searchResults: this.searchResults
                };
            }

            // 验证 AI 选择结果结构
            if (aiChoice && typeof aiChoice.类型 === 'string' && aiChoice.ID !== undefined && typeof aiChoice.选中理由 === 'string') {
                console.log('AI Choice:', aiChoice);

                // 1. 查找 AI 推荐的完整项目
                const recommendedItem = allItems.find(item => item.类型 === aiChoice.类型 && String(item.ID) === String(aiChoice.ID));

                let finalRecommendations = [];
                if (recommendedItem) {
                    const enhancedRecommendedItem = {
                        ...recommendedItem,
                        Content: recommendedItem.Content || '',
                        Location: recommendedItem.Location || '',
                        Time: recommendedItem.Time || '',
                        tags: recommendedItem.tags || [],
                        rating: recommendedItem.rating || null,
                        author: {
                            name: recommendedItem.author?.name || '匿名用户',
                            avatar: recommendedItem.author?.avatar || 'https://via.placeholder.com/20x20'
                        }
                    };
                    
                    finalRecommendations = [enhancedRecommendedItem];
                    console.log('Found Recommended Item:', enhancedRecommendedItem);
                } else {
                    console.warn(`AI 推荐的项目 (类型: ${aiChoice.类型}, ID: ${aiChoice.ID}) 在 allItems 中未找到!`);
                }

                        // 2. 更新推荐结果和重新筛选搜索结果（排除 AI 推荐项）
                        this.recommendations = finalRecommendations;
                        this.searchResults = allItems
                    .filter(item => !(item.类型 === aiChoice.类型 && String(item.ID) === String(aiChoice.ID)))
                            .slice(0, 30)
                    .map(item => ({
                        ...item,
                        Content: item.Content || '',
                        Location: item.Location || '',
                        Time: item.Time || '',
                        tags: item.tags || [],
                        rating: item.rating || null,
                        author: {
                            name: item.author?.name || '匿名用户',
                            avatar: item.author?.avatar || 'https://via.placeholder.com/20x20'
                        }
                    }));

                        // 3. 更新 showHotPot 逻辑
                        this.showHotPot = [...this.recommendations, ...this.searchResults].some(item => 
                            item.title && item.title.includes('火锅')
                        );

                console.log('Final Recommendations:', finalRecommendations);
                        console.log('Final Search Results:', this.searchResults);

                        // 4. 触发推荐结果的动画显示
                        this.$nextTick(() => {
                            this.animateRecommendations(); // 只显示推荐结果的动画
                        });

                // 返回最终结果，使用AI的选中理由作为最终描述
                return {
                    description: aiChoice.选中理由,
                    recommendations: finalRecommendations,
                            searchResults: this.searchResults
                };

            } else {
                console.error('Second AI 返回的 JSON 结构不符合预期:', aiChoice);
                        // 如果AI推荐格式不正确，也先展示搜索结果再返回
                        this.searchResults = allItems.slice(0, 30).map(item => ({
                            ...item,
                            Content: item.Content || '',
                            Location: item.Location || '',
                            Time: item.Time || '',
                            tags: item.tags || [],
                            rating: item.rating || null,
                            author: {
                                name: item.author?.name || '匿名用户',
                                avatar: item.author?.avatar || 'https://via.placeholder.com/20x20'
                            }
                        }));
                        
                return {
                    description: "抱歉，AI 推荐的格式不正确，为您展示所有找到的结果。",
                    recommendations: [],
                            searchResults: this.searchResults
                };
            }
        } else {
            throw new Error('Second AI 响应格式不正确');
        }
    } catch (error) {
        console.error('第二次调用 AI 或处理推荐失败:', error);
                // 即使AI调用失败，也展示之前获取到的搜索结果
                this.searchResults = allItems.slice(0, 30).map(item => ({
                    ...item,
                    Content: item.Content || '',
                    Location: item.Location || '',
                    Time: item.Time || '',
                    tags: item.tags || [],
                    rating: item.rating || null,
                    author: {
                        name: item.author?.name || '匿名用户',
                        avatar: item.author?.avatar || 'https://via.placeholder.com/20x20'
                    }
                }));
                
        return {
            description: `抱歉，生成推荐时遇到问题：${error.message}`,
            recommendations: [],
                    searchResults: this.searchResults
        };
    }
        },
// 辅助函数：将后端数据项映射到前端所需的统一格式
// 注意：你需要根据后端返回的实际字段来调整这个函数
mapItemToFrontendFormat(item, type) {
    // 默认结构
    let formattedItem = {
        类型: type, // '评论', '活动', '好友' 等
        ID: null,
        title: '未知标题',
        image: 'https://via.placeholder.com/100x80/CCCCCC/FFFFFF?text=No+Image', // 默认图片
        tags: [],
        Content: '无内容',
        Location: '未知位置',
        Time: '未知时间',
        Distance: '', // 距离信息
        link: null, // 关联度信息 - 新增
        author: { name: '匿名用户', avatar: 'https://via.placeholder.com/20x20/CCCCCC/FFFFFF?text=?' },
        activityTag: type === '活动' ? '活动' : null,
        rating: null,
        originalData: item // 保留原始数据以备后用
    };

    if (type === '评论' && item) {
        formattedItem.ID = item.commentId;
        formattedItem.title = item.commentTitle || '用户评论';
        formattedItem.Content = item.commentContent || '';
        formattedItem.Location = item.commentLocation || '';
        formattedItem.Distance = item.distance || '';
        formattedItem.link = item.link || item.relevance || null; // 获取关联度信息
        formattedItem.Time = item.commentPublishTime || '';
        formattedItem.tags = item.tags || [];
        formattedItem.author.name = item.publisherNickname || '匿名用户';
        formattedItem.author.avatar = item.publisherAvatar || formattedItem.author.avatar;
        formattedItem.rating = item.rating ? `${item.rating}` : null;
        formattedItem.image = item.commentImages && item.commentImages.length > 0 ? item.commentImages[0] : formattedItem.image;
    } else if (type === '活动' && item) {
        formattedItem.ID = item.activityId;
        formattedItem.title = item.activityTitle || '社区活动';
        formattedItem.Content = item.activityDetails || '';
        formattedItem.Location = item.activityLocation || '';
        formattedItem.Distance = item.distance || '';
        formattedItem.link = item.link || item.relevance || null; // 获取关联度信息
        formattedItem.Time = item.activityPublishTime || '';
        formattedItem.tags = item.tags || [];
        formattedItem.author.name = item.publisherNickname || '活动发起人';
        formattedItem.author.avatar = item.publisherAvatar || formattedItem.author.avatar;
        formattedItem.image = item.activityImages && item.activityImages.length > 0 ? item.activityImages[0] : formattedItem.image;
    } else if (type === '自己' && item) {
        formattedItem.类型 = item.类型;
        formattedItem.ID = item.ID;
        formattedItem.title = item.标题 || '我的记录';
        formattedItem.tags = item.tags || [];
        formattedItem.Content = item.activityDetails || item.commentContent || '';
        formattedItem.Location = item.activityLocation || item.commentLocation || '';
        formattedItem.Distance = item.distance || '';
        formattedItem.link = item.link || item.relevance || null; // 获取关联度信息
        formattedItem.Time = item.activityPublishTime || item.commentPublishTime || '';
        formattedItem.author.name = item.publisherNickname || '我';
        formattedItem.author.avatar = item.publisherAvatar || formattedItem.author.avatar;
        formattedItem.activityTag = item.类型 === '活动' ? '活动' : null;
        formattedItem.image = (item.commentImages || item.activityImages) && (item.commentImages || item.activityImages).length > 0 ? (item.commentImages || item.activityImages)[0] : formattedItem.image;
    }

    // 确保所有字段都有合理的值
    formattedItem.title = formattedItem.title || (type === '评论' ? '用户评论' : (type === '活动' ? '社区活动' : '未知内容'));
    console.log('Mapped Item with relevance:', formattedItem);
    return formattedItem;
},

search() {
    if (!this.searchText.trim()) return;
    // 新增：如果正在思考中，直接返回，防止重复搜索
    if (this.isThinking||this.isLoading) {
        console.log('AI正在思考中，跳过重复搜索请求 - isThinking:', this.isThinking, ', isLoading:', this.isLoading);
        return;
    }
    
    console.log('🚀 开始新的AI检索，搜索内容:', this.searchText);
    this.isLoading = true;
    this.isThinking = false; // 开始时不显示思考状态
    this.thinkingStage = 'analyzing'; // 设置思考阶段为分析
    this.startLoadingAnimation(); // 启动加载动画
    this.showContent = true; // 立即显示内容区域
    this.recommendations = [];
    this.searchResults = [];
    this.description = '正在分析您的搜索意图...'; // 初始化描述
    this.visibleRecommendations = [];
    this.visibleSearchResults = [];
    this.showHotPot = false; // 重置火锅店显示

    this.callAI(this.searchText)
        .then(aiResult => {
            // AI调用完成后，更新最终描述
            if (aiResult.description) {
                this.description = aiResult.description;
            } else {
                this.description = "未能获取推荐描述。";
            }

            this.thinkingStage = 'completed'; // 思考完成
            this.isThinking = false; // 结束思考状态
            
                    // 注意：recommendations 和 searchResults 已经在 callAI 中更新了
                    // 不需要在这里重新赋值，以避免覆盖 AI 处理的结果
        })
        .catch(error => {
            console.error("搜索过程中发生错误:", error);
            this.description = "抱歉，搜索时遇到问题，请稍后重试。";
            this.recommendations = [];
            this.searchResults = [];
            this.thinkingStage = 'completed'; // 即使出错也标记为完成
            this.isThinking = false; // 结束思考状态
        })
        .finally(() => {
            this.isLoading = false;
            this.stopLoadingAnimation();
        });
},

        // 新增：启动加载文本动画的方法
        startLoadingAnimation() {
            // 先立即显示一条
            this.currentLoadingText = this.loadingTexts[Math.floor(Math.random() * this.loadingTexts.length)];
            // 设置定时器，每隔一段时间切换文本
            this.loadingInterval = setInterval(() => {
                const randomIndex = Math.floor(Math.random() * this.loadingTexts.length);
                this.currentLoadingText = this.loadingTexts[randomIndex];
            }, 1500); // 每 1.5 秒切换一次，可以调整时间
        },

        // 新增：停止加载文本动画的方法
        stopLoadingAnimation() {
            if (this.loadingInterval) {
                clearInterval(this.loadingInterval);
                this.loadingInterval = null;
            }
        },
        
        // 逐条显示动画
        animateItems() {
            // 显示推荐结果
            for (let i = 0; i < this.recommendations.length; i++) {
                setTimeout(() => {
                    this.visibleRecommendations.push(i);
                }, i * 200);
            }
            
            // 显示搜索结果
            const recommendationDelay = this.recommendations.length * 200;
            for (let i = 0; i < this.searchResults.length; i++) {
                setTimeout(() => {
                    this.visibleSearchResults.push(i);
                }, recommendationDelay + i * 200);
            }
        },
        
        // 新增：只显示搜索结果的动画
        animateSearchResults() {
            // 清空之前的可见项
            this.visibleSearchResults = [];
            this.visibleRecommendations = [];
            
            // 逐条显示搜索结果
            for (let i = 0; i < this.searchResults.length; i++) {
                setTimeout(() => {
                    this.visibleSearchResults.push(i);
                }, i * 200);
            }
        },
        
        // 新增：只显示推荐结果的动画
        animateRecommendations() {
            // 清空推荐结果的可见项
            this.visibleRecommendations = [];
            
            // 逐条显示推荐结果
            for (let i = 0; i < this.recommendations.length; i++) {
                setTimeout(() => {
                    this.visibleRecommendations.push(i);
                }, i * 200);
            }
        },
        
        // 获取模拟数据
        getMockData() {
            return {
                description: `嗨，用户让我推荐他最爱吃的食物，根据用户历史喜好分析，用户在往期选择中选择烤鸡类食物较多，所以我可以提供一些烤鸡食物。\n尽管我可以尝试从用户历史中为你提供更多相关的食物推荐，这个答案可能不是最理想的回答，但是为了提供更加准确的推荐，我可以尝试从好友中给你一个更好的相关推荐。`,
                recommendations: [
                    {
                        title: '一起吃烤鸭',
                        image: 'https://via.placeholder.com/100x80',
                        tags: ['美食', '北京味道', '多人'],
                        author: {
                            name: '波比不熬夜',
                            avatar: 'https://via.placeholder.com/20x20'
                        },
                        activityTag: '活动',
                        rating: '2'
                    }
                ],
                searchResults: [
                    {
                        title: '一起吃宫菜',
                        image: 'https://via.placeholder.com/100x80',
                        tags: ['美食', '北京味道', '多人'],
                        author: {
                            name: '波比不熬夜',
                            avatar: 'https://via.placeholder.com/20x20'
                        },
                        activityTag: '活动',
                        rating: '2'
                    },
                    {
                        title: '超级火锅店',
                        image: 'https://via.placeholder.com/100x80',
                        tags: ['火锅', '聚餐'],
                        author: {
                            name: '美食达人',
                            avatar: 'https://via.placeholder.com/20x20'
                        }
                    }
                ]
            };
        },
        
        // 打开详情页
        openDetail(item) {
            
            console.log('打开详情页:', item.title);
            Android.openActivity(item.title);
            //alert('即将打开详情页: ' + item.title);
            // 实际应用中这里会跳转到详情页
        },
            // 处理活动项目点击
        openactivities(item) {
            console.log('打开活动详情:', item);
            // 这里添加打开活动详情的逻辑
            // 例如跳转到活动详情页面
            Android.openActivity(item.ID);
            // window.location.href = `/activity.html?id=${item.ID}`;
        },
        
        // 处理评论项目点击
        opencomments(item) {
            console.log('打开评论详情:', item);
            // 这里添加打开评论详情的逻辑
            // 例如跳转到评论详情页面
            Android.openReview(item.ID);
            // window.location.href = `/comment.html?id=${item.ID}`;
        },
        // 自动滚动thinking-text到底部
        // 滚动思考文本到底部（带节流控制）
        scrollThinkingTextToBottom() {
            // 检查是否在节流期间
            const currentTime = Date.now();
            if (this.isScrollAnimating || (currentTime - this.lastScrollTime < this.scrollInterval)) {
                console.log('滚动被节流限制，跳过本次滚动');
                return;
            }

            this.$nextTick(() => {
                const thinkingTextElement = document.querySelector('.thinking-text');
                if (thinkingTextElement) {
                    // 设置滚动动画标志
                    this.isScrollAnimating = true;
                    this.lastScrollTime = currentTime;
                    
                    // 检测内容是否超过3行，决定是否显示遮罩
                    this.checkAndApplyMask(thinkingTextElement);
                    // 执行滚动
                    this.scrollToBottom(thinkingTextElement);
                    
                    console.log('执行滚动动画，时间:', new Date(currentTime).toLocaleTimeString());
                }
            });
        },
        
        // 检测内容高度并决定是否应用遮罩
        checkAndApplyMask(element) {
            // 计算大概的行数：scrollHeight / (font-size * line-height)
            // font-size: 14px, line-height: 1.5, 所以每行约21px
            const lineHeight = 21; // 14 * 1.5 = 21px
            const estimatedLines = element.scrollHeight / lineHeight;
            
            // 如果内容超过3行，添加遮罩；否则移除遮罩
            if (estimatedLines > 3) {
                element.classList.add('has-mask');
            } else {
                element.classList.remove('has-mask');
            }
            
            console.log(`思考内容行数: ${estimatedLines.toFixed(1)}, 是否显示遮罩: ${estimatedLines > 3}`);
        },
        
        // 自定义平滑滚动函数（缓动动画）
        // 自定义平滑滚动函数（缓动动画）- 增加完成回调
        smoothScrollTo(element, targetScrollTop, duration) {
            const startScrollTop = element.scrollTop;
            const distance = targetScrollTop - startScrollTop;
            const startTime = performance.now();
            
            const easeInOutCubic = (t) => {
                return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
            };
            
            const animateScroll = (currentTime) => {
                const timeElapsed = currentTime - startTime;
                const progress = Math.min(timeElapsed / duration, 1);
                const easedProgress = easeInOutCubic(progress);
                
                element.scrollTop = startScrollTop + distance * easedProgress;
                
                if (progress < 1) {
                    requestAnimationFrame(animateScroll);
                } else {
                    // 动画完成，重置滚动状态
                    this.isScrollAnimating = false;
                    console.log('滚动动画完成，重置状态');
                }
            };
            
            requestAnimationFrame(animateScroll);
        },
        
        // 更新思考内容并检测遮罩（带节流控制）
        updateThinkingContent(content) {
            this.description = content;
            // 使用节流控制的滚动方法
            this.scrollThinkingTextToBottom();
            console.log('思考内容更新:', content);
        },
        
        // 单独的滚动方法（增加动画完成回调）
        scrollToBottom(element) {
            // 检查是否支持smooth behavior
            if ('scrollBehavior' in document.documentElement.style) {
                // 使用原生平滑滚动
                element.scrollTo({
                    top: element.scrollHeight,
                    behavior: 'smooth'
                });
                
                // 原生滚动没有完成事件，使用定时器模拟
                setTimeout(() => {
                    this.isScrollAnimating = false;
                    console.log('原生滚动完成，重置状态');
                }, 300); // 假设原生滚动需要300ms
            } else {
                // 使用自定义缓动动画（会在完成时自动重置状态）
                this.smoothScrollTo(element, element.scrollHeight, 300);
            }
        },

        // 新增：根据关键词过滤内容的辅助函数
        filterContentByKeywords(content, keywords) {
            if (!keywords || keywords.length === 0) {
                return content;
            }
            
            return content.filter(item => {
                const searchText = `${item.标题 || ''} ${item.内容 || ''}`.toLowerCase();
                return keywords.some(keyword => 
                    searchText.includes(keyword.toLowerCase())
                );
            });
        },

        // 新增：根据关键词优化项目排序的辅助函数  
        optimizeItemsByKeywords(items, keywords) {
            if (!keywords || keywords.length === 0) {
                return items;
            }
            
            // 给每个项目计算关键词匹配分数
            const itemsWithScore = items.map(item => {
                const searchText = `${item.title || ''} ${item.Content || ''}`.toLowerCase();
                let score = 0;
                
                keywords.forEach(keyword => {
                    const lowerKeyword = keyword.toLowerCase();
                    if (searchText.includes(lowerKeyword)) {
                        // 标题匹配权重更高
                        if ((item.title || '').toLowerCase().includes(lowerKeyword)) {
                            score += 10;
                        }
                        // 内容匹配
                        if ((item.Content || '').toLowerCase().includes(lowerKeyword)) {
                            score += 5;
                        }
                        // 完全匹配加分
                        if (searchText === lowerKeyword) {
                            score += 20;
                        }
                    }
                });
                
                return {
                    ...item,
                    _keywordScore: score
                };
            });
            
            // 按分数排序，分数高的在前面
            itemsWithScore.sort((a, b) => b._keywordScore - a._keywordScore);
            
            // 移除临时的分数属性
            return itemsWithScore.map(item => {
                const { _keywordScore, ...cleanItem } = item;
                return cleanItem;
            });
        },

        // 修改：按关联度和距离排序的辅助函数
        sortItemsByRelevanceAndDistance(items) {
            // 创建一个副本，避免修改原数组
            const sortedItems = [...items];
            
            // 按关联度和距离排序
            sortedItems.sort((a, b) => {
                // 1. 优先使用关联度（link值）排序
                const linkA = this.parseRelevanceScore(a.link || a.Link);
                const linkB = this.parseRelevanceScore(b.link || b.Link);
                
                // 如果都有关联度值，按关联度排序（值越大关联度越高，排在前面）
                if (linkA !== null && linkB !== null) {
                    if (linkA !== linkB) {
                        return linkB - linkA; // 降序，关联度高的在前
                    }
                } else if (linkA !== null && linkB === null) {
                    // A有关联度，B没有，A排在前面
                    return -1;
                } else if (linkA === null && linkB !== null) {
                    // B有关联度，A没有，B排在前面
                    return 1;
                }
                
                // 2. 如果关联度相同或都没有关联度，则使用距离排序
                const distanceA = this.parseDistance(a.Distance);
                const distanceB = this.parseDistance(b.Distance);
                
                // 距离近的排在前面
                if (distanceA !== distanceB) {
                    return distanceA - distanceB;
                }
                
                // 3. 如果距离也相同，按类型排序：活动优先于评论
                const typeOrder = { '活动': 0, '评论': 1, '自己': 2 };
                const typeA = typeOrder[a.类型] || 999;
                const typeB = typeOrder[b.类型] || 999;
                
                if (typeA !== typeB) {
                    return typeA - typeB;
                }
                
                // 4. 如果类型也相同，按时间排序（最新的在前）
                const timeA = new Date(a.Time || 0);
                const timeB = new Date(b.Time || 0);
                return timeB - timeA;
            });
            
            console.log('关联度和距离排序详情:', sortedItems.map(item => ({
                类型: item.类型,
                标题: item.title,
                关联度: item.link || item.Link || '无',
                解析关联度: this.parseRelevanceScore(item.link || item.Link),
                距离: item.Distance,
                解析距离: this.parseDistance(item.Distance)
            })));
            
            return sortedItems;
        },

        // 新增：解析关联度分数的辅助函数
        parseRelevanceScore(linkValue) {
            if (linkValue === undefined || linkValue === null || linkValue === '') {
                return null; // 没有关联度信息
            }
            
            // 如果是数字类型，直接返回
            if (typeof linkValue === 'number') {
                return linkValue;
            }
            
            // 如果是字符串，尝试转换为数字
            const numValue = parseFloat(String(linkValue));
            if (!isNaN(numValue)) {
                return numValue;
            }
            
            // 无法解析的情况
            return null;
        },

        // 新增：解析距离字符串为数字的辅助函数
        parseDistance(distanceStr) {
            if (!distanceStr) return 999999; // 无距离信息的排在最后
            
            // 如果是数字类型，直接返回
            if (typeof distanceStr === 'number') {
                return distanceStr;
            }
            
            // 如果是字符串，尝试提取数字
            const str = String(distanceStr).toLowerCase();
            
            // 处理各种距离格式
            if (str.includes('公里') || str.includes('km')) {
                const match = str.match(/(\d+\.?\d*)/);
                return match ? parseFloat(match[1]) : 999999;
            }
            
            // 处理米为单位的距离
            if (str.includes('米') || str.includes('m')) {
                const match = str.match(/(\d+\.?\d*)/);
                return match ? parseFloat(match[1]) / 1000 : 999999; // 转换为公里
            }
            
            // 处理纯数字
            const numMatch = str.match(/(\d+\.?\d*)/);
            if (numMatch) {
                return parseFloat(numMatch[1]);
            }
            
            // 无法解析的情况
            return 999999;
        },
    },
    // 新增：在组件销毁前清除定时器，防止内存泄漏
    beforeDestroy() {
        this.stopLoadingAnimation();
    }
});